home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / languages / obrn-a_1.5_lib.lha / oberon-a / source2.lha / Source / Obsolete / BigSets.mod < prev    next >
Encoding:
Text File  |  1995-01-26  |  4.5 KB  |  190 lines
  1. (***************************************************************************
  2.  
  3.      $RCSfile: BigSets.mod $
  4.   Description: An implementation of sets bigger than a machine word.
  5.  
  6.    Created by: fjc (Frank Copeland)
  7.     $Revision: 1.7 $
  8.       $Author: fjc $
  9.         $Date: 1995/01/26 00:46:19 $
  10.  
  11.   Copyright © 1994, Frank Copeland.
  12.   This file is part of the Oberon-A Library.
  13.   See Oberon-A.doc for conditions of use and distribution.
  14.  
  15. ***************************************************************************)
  16.  
  17. <* MAIN- *>
  18.  
  19. MODULE BigSets;
  20.  
  21. <*$ LongVars+ *>
  22.  
  23. IMPORT U := Util;
  24.  
  25. CONST
  26.  
  27.   BitsPerSet * = MAX (SET) + 1;
  28.   CharSetElements = ORD (MAX (CHAR)) DIV BitsPerSet;
  29.  
  30. TYPE
  31.  
  32.   CHARSET * = ARRAY CharSetElements OF SET;
  33.  
  34. (*------------------------------------*)
  35. PROCEDURE Empty * ( VAR set : ARRAY OF SET );
  36.  
  37.   VAR index : INTEGER;
  38.  
  39. BEGIN (* Empty *)
  40.   index := 0;
  41.   WHILE index < LEN (set) DO
  42.     set [index] := {};
  43.     INC (index)
  44.   END; (* WHILE *)
  45. END Empty;
  46.  
  47. (*------------------------------------*)
  48. PROCEDURE IsEmpty * ( VAR set : ARRAY OF SET ) : BOOLEAN;
  49.  
  50.   VAR index : INTEGER; empty : BOOLEAN;
  51.  
  52. BEGIN (* IsEmpty *)
  53.   empty := TRUE; index := 0;
  54.   WHILE empty & (index < LEN (set)) DO
  55.     empty := (set [index] = {});
  56.     INC( index );
  57.   END; (* WHILE *)
  58.   RETURN empty;
  59. END IsEmpty;
  60.  
  61. (*------------------------------------*)
  62. PROCEDURE In * ( VAR set : ARRAY OF SET; element : INTEGER ) : BOOLEAN;
  63.  
  64.   VAR index, bit : INTEGER;
  65.  
  66. BEGIN (* In *)
  67.   index := element DIV BitsPerSet;
  68.   bit := element MOD BitsPerSet;
  69.   RETURN (bit IN set [index]);
  70. END In;
  71.  
  72. (*------------------------------------*)
  73. PROCEDURE Incl * ( VAR set : ARRAY OF SET; element : INTEGER );
  74.  
  75.   VAR index, bit : INTEGER;
  76.  
  77. BEGIN (* Incl *)
  78.   index := element DIV BitsPerSet;
  79.   bit := element MOD BitsPerSet;
  80.   INCL (set [index], bit);
  81. END Incl;
  82.  
  83. (*------------------------------------*)
  84. PROCEDURE Excl * ( VAR set : ARRAY OF SET; element : INTEGER );
  85.  
  86.   VAR index, bit : INTEGER;
  87.  
  88. BEGIN (* Excl *)
  89.   index := element DIV BitsPerSet;
  90.   bit := element MOD BitsPerSet;
  91.   EXCL (set [index], bit);
  92. END Excl;
  93.  
  94. (*------------------------------------*)
  95. PROCEDURE InclRange * (
  96.   VAR set : ARRAY OF SET; firstElement, lastElement : INTEGER );
  97.  
  98.   VAR index, bit, count : INTEGER;
  99.  
  100. BEGIN (* InclRange *)
  101.   index := firstElement DIV BitsPerSet;
  102.   bit := firstElement MOD BitsPerSet;
  103.   count := lastElement - firstElement + 1;
  104.   WHILE count > 0 DO
  105.     INCL (set [index], bit);
  106.     INC (bit);
  107.     IF bit = BitsPerSet THEN
  108.       bit := 0;
  109.       INC (index);
  110.     END; (* IF *)
  111.     DEC (count);
  112.   END; (* WHILE *)
  113. END InclRange;
  114.  
  115. (*------------------------------------*)
  116. PROCEDURE ExclRange * (
  117.   VAR set : ARRAY OF SET; firstElement, lastElement : INTEGER );
  118.  
  119.   VAR index, bit, count : INTEGER;
  120.  
  121. BEGIN (* ExclRange *)
  122.   index := firstElement DIV BitsPerSet;
  123.   bit := firstElement MOD BitsPerSet;
  124.   count := lastElement - firstElement + 1;
  125.   WHILE count > 0 DO
  126.     EXCL (set [index], bit);
  127.     INC (bit);
  128.     IF bit = BitsPerSet THEN
  129.       bit := 0;
  130.       INC (index);
  131.     END; (* IF *)
  132.     DEC (count);
  133.   END; (* WHILE *)
  134. END ExclRange;
  135.  
  136. (*------------------------------------*)
  137. PROCEDURE Union * ( VAR firstSet, secondSet, destSet : ARRAY OF SET );
  138.  
  139.   VAR index, maxIndex : INTEGER;
  140.  
  141. BEGIN (* Union *)
  142.   index := 0; maxIndex := SHORT (LEN (firstSet));
  143.   WHILE index < maxIndex DO
  144.     destSet [index] := firstSet [index] + secondSet [index];
  145.     INC (index)
  146.   END; (* WHILE *)
  147. END Union;
  148.  
  149. (*------------------------------------*)
  150. PROCEDURE Difference * ( VAR firstSet, secondSet, destSet : ARRAY OF SET );
  151.  
  152.   VAR index, maxIndex : INTEGER;
  153.  
  154. BEGIN (* Difference *)
  155.   index := 0; maxIndex := SHORT (LEN (firstSet));
  156.   WHILE index < maxIndex DO
  157.     destSet [index] := firstSet [index] - secondSet [index];
  158.     INC (index)
  159.   END; (* WHILE *)
  160. END Difference;
  161.  
  162. (*------------------------------------*)
  163. PROCEDURE Intersection * (VAR firstSet, secondSet, destSet : ARRAY OF SET);
  164.  
  165.   VAR index, maxIndex : INTEGER;
  166.  
  167. BEGIN (* Intersection *)
  168.   index := 0; maxIndex := SHORT (LEN (firstSet));
  169.   WHILE index < maxIndex DO
  170.     destSet [index] := firstSet [index] * secondSet [index];
  171.     INC (index)
  172.   END; (* WHILE *)
  173. END Intersection;
  174.  
  175. (*------------------------------------*)
  176. PROCEDURE SymmetricDiff * (VAR firstSet, secondSet, destSet : ARRAY OF SET);
  177.  
  178.   VAR index, maxIndex : INTEGER;
  179.  
  180. BEGIN (* SymmetricDiff *)
  181.   index := 0; maxIndex := SHORT (LEN (firstSet));
  182.   WHILE index < maxIndex DO
  183.     destSet [index] := firstSet [index] / secondSet [index];
  184.     INC (index)
  185.   END; (* WHILE *)
  186. END SymmetricDiff;
  187.  
  188. END BigSets.
  189.  
  190.